#ifndef COMMANDUTILS_H
# define COMMANDUTILS_H

#include <sys/wait.h>

#include "core.h"
#include "fileutils.h"

// not avaliable
bool waitToFinish(FILE *fp);

bool foundCommand(char *cmd);

// only line stdout
bool getCmdStdoutLine(char *cmd, char *buffer);

// only read stdout of len
bool getCmdStdoutFull(char *cmd, char *buffer, size_t len);

#define CMD_IS_EXIT(s) WIFEXITED(s)
typedef bool(*CMD_IS_EXIT)(int);
#define CMD_EXIT_STATUS(s) WEXITSTATUS(s)
typedef bool(*CMD_EXIT_STATUS)(int);

// fork()

#endif


// ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
// │ WIFEXITED(status)                                                                                                    │
// │     True if the process terminated normally by a call to _exit(2) or exit(3).                                        │
// ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
// │ WIFSIGNALED(status)                                                                                                  │
// │     True if the process terminated due to receipt of a signal.                                                       │
// ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
// │ WIFSTOPPED(status)                                                                                                   │
// │     True if the process has not terminated, but has stopped and can be restarted.  This macro can be true only if    │
// │ the wait call specified the WUNTRACED option or if the child process is                                              │
// │ being traced (see ptrace(2)).                                                                                        │
// ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
// │ Depending on the values of those macros, the following macros produce the remaining status information about the     │
// │ child process:                                                                                                       │
// ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
// │ WEXITSTATUS(status)                                                                                                  │
// │     If WIFEXITED(status) is true, evaluates to the low-order 8 bits of the argument passed to _exit(2) or exit(3)    │
// │ by the child.                                                                                                        │
// ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
// │ WTERMSIG(status)                                                                                                     │
// │     If WIFSIGNALED(status) is true, evaluates to the number of the signal that caused the termination of the         │
// │ process.                                                                                                             │
// ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
// │ WCOREDUMP(status)                                                                                                    │
// │     If WIFSIGNALED(status) is true, evaluates as true if the termination of the process was accompanied by the       │
// │ creation of a core file containing an image of the process when the signal                                           │
// │ was received.                                                                                                        │
// ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
// │ WSTOPSIG(status)                                                                                                     │
// │     If WIFSTOPPED(status) is true, evaluates to the number of the signal that caused the process to stop.            │
// └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘